#coding = utf-8
from nonebot import on_command, CommandSession, scheduler
from apscheduler.triggers.date import DateTrigger # 一次性触发器
import aiohttp,nonebot,json,aiofiles,subprocess,re
from os import path
from aiocqhttp.exceptions import Error as CQHttpError
import traceback

import datetime
#现在已经没有警报了
##留意一下559
##涉及时间432
##events中有热美亚裂缝
## syndicateMissions 中是集团任务
## flashSales 里是什么呢？
## invasions 里是入侵（已有）
## darkSectors 里是什么？
## voidTrader 里是虚空商人（来的时间？）
  ## inventory 里是物品
## dailyDeals 里是每日特惠（已有）
## simaris 里的是什么？（每日目标吗？每个人不一样吧？）
## conclaveChallenges 里是什么？（武形秘仪挑战？）
## persistentEnemies？？
## earthCycle（地球，已有）
## cetusCycle（希图斯，已有）
## weeklyChallenges 每周挑战？
## constructionProgress 建造进度，巨人战舰和豺狼
## vallisCycle 金星平原吧？
## nightwave 午夜电波（似乎已有）
## kuva 赤毒
## arbitration 仲裁
## sentientOutposts 是什么？那个面纱星的s系飞船？
## twitter 似乎已有（把这沙雕功能给关了吧）

### startString参数应该是指离开始已经过去了多久
### 表示剩余时间的格式 "xm xs", "xh xm xs"


earthtime=None
cetustime=None
vallistime=None

debug=1
dict_debug=0
parsed_full_dict=[]
if debug==1:
    print("parsed_full_dict在初始化时的地址为："+str(id(parsed_full_dict)))
parsed_sale_dict=[]
parsed_invasion=[]
parsed_nightwave=[]
parsed_json = dict()##存储获取的json
group_list=[739060938,414922009,]##自己添加的，代表需要发送消息的群。

invasion_old_list=[]##旧的入侵列表
#twitter_old_list=[]##旧的推文列表
news_old_list=[]##旧的新闻列表

latest_UPT=0#最近的更新时间


##每x分钟自动更新json
##获取信息->处理，警报，入侵，裂隙等，高稀有度的直接广播；其他的等有人要查再私发
##翻译模块如果不是数据库的话用绝对路径处理吧，别人也好改

###翻译
#手动更新词典，输入 设置 调用
@on_command('settings', aliases=('设置',), only_to_me=False)
async def settings(session: CommandSession):
    try:
        await dict_updater()
    except:
        print("settings函数出错")
        traceback.print_exc()

async def dict_updater():
    try:
        global parsed_full_dict,parsed_nightwave,parsed_sale_dict,parsed_invasion
        file_path = 'C:\\Q\\WFdeBot\\plugins.\\wfbot\\WFA_Lexicon-WFA5'
        async with aiofiles.open(file_path+'\\WF_Dict.json',encoding='UTF-8', mode='r') as f:
            contents = await f.read()
            parsed_full_dict = json.loads(contents)
        async with aiofiles.open(file_path+'\\WF_Sale.json', encoding='UTF-8', mode='r') as f:
            contents = await f.read()
            parsed_sale_dict = json.loads(contents)
        async with aiofiles.open(file_path+'\\WF_NightWave.json', encoding='UTF-8', mode='r') as f:
            contents = await f.read()
            parsed_nightwave = json.loads(contents)
        async with aiofiles.open(file_path+'\\WF_Invasion.json', encoding='UTF-8', mode='r') as f:
            contents = await f.read()
            parsed_invasion = json.loads(contents)
        if debug==1:
            print("设置完成！")
    except:
        print("dict_updater函数出错")
        traceback.print_exc()

def get_timedelta(basetime):
    try:
        time_now=datetime.datetime.now()
        timedelta=basetime-time_now
        text=""
        if timedelta.days != 0:
            text+=str(timedelta.days)+"d "
        if timedelta.seconds != 0:
            m=int(timedelta.seconds/60)#得到分钟数
            h=int(m/60)
            if h != 0:
                m=m-h*60
                text+=str(h)+"h "
            if m !=0:
                text+=str(m)+"m "
            s=timedelta.seconds-m*60-h*3600
            text+=str(s)+"s "
        return text
    except:
        print('get_timedelta函数出错')
        traceback.print_exc()
        return "出错"

# 从字典中寻找翻译 中译英或英→中
##校对完毕，什么时候可以改成数据库？
async def dict_translator(ori_text, using_dict = None):#对于变量名我有很多的疑惑（想起来了指针的好处，可惜python没有）
    global parsed_full_dict,parsed_nightwave,parsed_sale_dict,parsed_invasion,debug,dict_debug
    try:
        if(debug==1):
            print("使用dict_translator函数，传入字符串为 "+ori_text)
        if using_dict==None:
            if(debug==1):
                print("未传入字典，使用默认字典")
            using_dict = parsed_full_dict
        if using_dict:
            if(debug==1):
                print("修改后的字典有效")
        if using_dict != None:
            print('修改后的字典无效')
        if debug==1:
            print("dict_translator中，使用的字典的地址为："+str(id(using_dict))+" 字典的类型为："+str(type(using_dict)))
        #下面这句话检测是否包含中文
        if re.match(r'[\u4e00-\u9fa5]',ori_text):
            if(debug==1):
                print("中转英")
            en_str = ''#中文翻译为英文
            if(debug==1):
                print("开始匹配")
            for x in using_dict:
                if(dict_debug==1):
                    print("正在比较的id为："+str(x['id']))
                if ori_text.replace(' ','').lower() == x['zh'].replace(' ','').lower():##为什么要对中文用lower()？原为str.replace(' ','').lower()
                    if(debug==1):
                        print("匹配！匹配项为：")
                        print(x)
                    en_str = x['en']
                    break
            if en_str:
                return en_str
            else:
                if debug==1:
                    print("无匹配项")
                return ori_text
        else:
            if(debug==1):
                print("英转中")
            zh_str = ''
            if(debug==1):
                print("开始匹配")
            for x in using_dict:
                if dict_debug==1:
                    print("正在比较的id为："+str(x['id']))
                if ori_text.replace(' ','').lower() == x['en'].replace(' ','').lower():
                    if(debug==1):
                        print("匹配！匹配项为：")
                        print(x)
                    zh_str = x['zh']
                    break
            if debug==1:
                print("匹配结束")
            if zh_str:
                return zh_str
            else:
                if debug==1:
                    print("无匹配项")
                return ori_text
    except:
        traceback.print_exc()
        return "翻译模块出错"
        

###获取
async def fetch(session, url):
    try:
        async with session.get(url) as response:
            return await response.text()#直接用return会返回一个coroutine对象，且会抛出一个StopIteration异常，而原来的返回值会存放在StopIteration对象的value属性中
    except:
        print("fetch函数出错")
        traceback.print_exc()
        return None

# 每分钟抓取Warframe世界信息
@nonebot.scheduler.scheduled_job('interval', minutes=2)
async def _parser():
    global parsed_json
    try:
        #bot = nonebot.get_bot()
        #await bot.send_private_msg(user_id=2595271955,message="获取数据定时任务启动")
        async with aiohttp.ClientSession() as session:
            html = await fetch(session,'https://ws.warframestat.us/pc')
            print("_parser函数中html的类型为：")
            print(type(html))
            if html==None:#未获取到信息
               print("无法从网站获取到信息")
            else:
                parsed_json = json.loads(html)
                set_UPT()
    except CQHttpError:
        print("发送时出错")
    except:
        print("_parser函数出错")
        traceback.print_exc()


'''
计算当前时间向后8个小时的时间
>>> d1 = datetime.datetime.now()
>>> d2 = d1 + datetime.timedelta(hours = 8)
>>> d2
datetime.datetime(2017, 3, 23, 1, 10, 37, 182240)
'''
def set_UPT():
    global parsed_json,debug,earthtime,cetustime,vallistime
    try:
        time_now=datetime.datetime.now()#获取当前时间
        d=9999
        h=9999
        m=9999
        s=9999
        times=None
        #遍历得到的WF信息，获取最短时间
        a=parsed_json.get('fissures')#裂隙, a list
        if a:
            for i in a:# a dict
                eta=i.get('eta')
                if eta:
                    times=re.match('([0-9]*)??d?\s?([0-9]*)??h?\s?([0-9]*)??m?\s?([0-9]*)??s?$',eta,re.I)
                    if times:
                        td=int((times.group(1) or 0))
                        th=int((times.group(2) or 0))
                        tm=int((times.group(3) or 0))
                        ts=int((times.group(4) or 0))

                        if(td<=d and th<=tm and tm<=m and ts<s):
                            d=td
                            h=th
                            m=tm
                            s=ts
        a=parsed_json.get('earthCycle')#地球时间，a dict
        if a:
            eta=a.get('timeLeft')
            if eta:
                times=re.match('([0-9]*)??d?\s?([0-9]*)??h?\s?([0-9]*)??m?\s?([0-9]*)??s?$',eta,re.I)
                if times:
                    td=int((times.group(1) or 0))
                    th=int((times.group(2) or 0))
                    tm=int((times.group(3) or 0))
                    ts=int((times.group(4) or 0))
                    earthtime=time_now+datetime.timedelta(days=td,seconds=ts,minutes=tm,hours=th)
                    if(td<=d and th<=tm and tm<=m and ts<s):
                        d=td
                        h=th
                        m=tm
                        s=ts
        a=parsed_json.get('cetusCycle')#希图斯，a dict
        if a:
            eta=a.get('timeLeft')
            if eta:
                times=re.match('([0-9]*)??d?\s?([0-9]*)??h?\s?([0-9]*)??m?\s?([0-9]*)??s?$',eta,re.I)
                if times:
                    td=int((times.group(1) or 0))
                    th=int((times.group(2) or 0))
                    tm=int((times.group(3) or 0))
                    ts=int((times.group(4) or 0))
                    cetustime=time_now+datetime.timedelta(days=td,seconds=ts,minutes=tm,hours=th)
                    if(td<=d and th<=tm and tm<=m and ts<s):
                        d=td
                        h=th
                        m=tm
                        s=ts
        a=parsed_json.get('vallisCycle')#金星平原？
        if a:
            eta=a.get('timeLeft')
            if eta:
                times=re.match('([0-9]*)??d?\s?([0-9]*)??h?\s?([0-9]*)??m?\s?([0-9]*)??s?$',eta,re.I)
                if times:
                    td=int((times.group(1) or 0))
                    th=int((times.group(2) or 0))
                    tm=int((times.group(3) or 0))
                    ts=int((times.group(4) or 0))
                    vallistime=time_now+datetime.timedelta(days=td,seconds=ts,minutes=tm,hours=th)
                    if(td<=d and th<=tm and tm<=m and ts<s):
                        d=td
                        h=th
                        m=tm
                        s=ts
        #时间比较完毕，设置定时任务
        #recent_time=time_now+datetime.timedelta(days=d,seconds=s,minutes=m,hours=h)
        #制作一个触发器
        #trigger=DateTrigger(recent_time)
        #添加任务
        #scheduler.add_job(func=_parser,trigger=trigger,misfire_grace_time=10)
    except:
        print("set_UPT函数出错")
        traceback.print_exc()

# list中事件整合为字符串
##应该是校对完了
async def join_list_to_str(raw_list,head_str=''):
    try:
        if raw_list:
            for index,x in enumerate(raw_list):
                if index == 0:
                    head_str = head_str + '\n' + x
                else:
                    head_str =head_str + '\n\n'+x
        return head_str   
    except:
        print("join_list_to_str函数出错")
        traceback.print_exc()

#警报功能已去除
# 格式化警报字符串 str → str(输入为alert中的每一项)
#在新的里还没找到
'''
async def get_alert_text(raw_str):
    try:
        if raw_str:
            reward = raw_str['mission']['reward']['itemString']
            mission_type = await dict_translator(raw_str['mission']['type'])
            mission_node = await node_translator(raw_str['mission']['node'])
            eta = raw_str['eta']
            reward = await dict_translator(reward)##用到字典翻译奖励为中文
            alert_text = '节点：{node}\n类型：{type}\n奖励：{reward}\n剩余时间：{eta}'.format(node=mission_node,type=mission_type,eta=eta,reward=reward)
            return alert_text
    except:
        print("get_alret_text函数出错")
        traceback.print_exc()

''' 

# 格式化入侵字符串 有同名函数
'''
async def get_invasion_text(raw_str):
    completion = int(raw_str['completion'])
    node = await node_translator(raw_str['node'])
    aFaction = raw_str['attackingFaction']
    dFaction = raw_str['defendingFaction']
    aReward = await invasion_reward_translator(raw_str['attackerReward']['asString'])
    dReward = await invasion_reward_translator(raw_str['defenderReward']['asString'])
    text = '节点：{node}\n阵营：{aFaction} Vs {dFaction}\n奖励：{aReward} Vs {dReward}\n进度：{completion}'.format(aFaction=aFaction,dFaction=dFaction,node=node,aReward=aReward,dReward=dReward,completion=completion)
    return text
'''

####新旧列表处理
##应该已经校对了
#从event_list中获取id_list,identifier是id的key
async def get_id_list(event_list,identifier='id'):
    try:
        id_list = []
        if event_list:
            for event in event_list:
                id = event[identifier]
                id_list.append(id)
        return id_list
    except:
        print("get_id_list函数出错")
        traceback.print_exc()


# 格式化新闻列表，输入输出均为list
# 应该已经校对完了
async def get_news_list(raw_list):
    try:
        new_list=[]
        if raw_list:
            for x in raw_list:
                if not ('en' in x['translations'] or 'zh' in x['translations']):
                    #raw_list.remove(x)##？？？
                    continue
                if 'zh' in x['translations']:
                    new_str='新闻标题:'+x['translations']['zh']+'\n链接:'+x['link']+'\n'
                else:
                    new_str='新闻标题:'+x['translations']['en']+'\n链接:'+x['link']+'\n'
                new_list.append(new_str)
        return new_list
    except:
        print("get_news_list函数出错")
        traceback.print_exc()
        return "出错"

# 格式化推文列表，输入输出均为list
'''
async def get_twitter_list(raw_list):
    try:
        new_list =[]
        if raw_list:
            for x in raw_list:
                if not (x['id']=='twitter.warframe.tweet'):
                    raw_list.remove(x)
                    continue
                str = '推文正文:'+x['tweets'][0]['full_text']
                new_list.append(str)
        return new_list
    except:
        print("get_twitter_list出错")
        traceback.print_exc()
        return None
'''

# 每分钟第1秒获得旧列表（为了和新列表比较，获取新增事件）
## 应该已经校对完了
@nonebot.scheduler.scheduled_job('interval', minutes=3)#改为每两分钟的第一秒
async def _get_old_lists():
    global invasion_old_list,news_old_list,group_list
    try:
        if parsed_json:
            invasion_old_list = await get_id_list(parsed_json['invasions'])
            news_old_list = await get_id_list(parsed_json['news'])
    except:
        print("_get_old_list出错")
        traceback.print_exc()

# 比较新旧获取新的事件列表
##应该已经校对完了
async def get_new_events(old_list,current_list,identifier='id'):
    try:
        new_list=[]
        if current_list:
            for event in current_list:
                if not (event[identifier] in old_list):
                    new_list.append(event)
        return new_list
    except:
        print("get_new_evevnts函数出错")
        traceback.print_exc()
        return None

####新警报播报
# 每分钟的40秒自动广播新入侵，新闻 ，20191026：警报已取消
##应该已经校对完了
@nonebot.scheduler.scheduled_job('interval', minutes=6)
async def _new_events_broadcaster():
    try:
        new_invasions = await get_new_events(invasion_old_list,parsed_json['invasions'])
        rare_list=[]
        if new_invasions:
            for x in new_invasions:
                for y in ('forma','exilus','reactor','catalyst'):    #稀有入侵筛选
                    if y in x['rewardTypes']:
                        rare_list.append(await get_invasion_text(x))
                        break
                        
        #new_twitter = await get_twitter_list(await get_new_events(twitter_old_list,parsed_json['twitter'],'uniqueId'))
        #if rare_list or new_twitter:
        if rare_list:
            bot = nonebot.get_bot()
            for group in group_list:
                #some_list = [rare_list,new_twitter]
                #for x in some_list:
                for x in rare_list:
                    if x:
                        for y in x:
                            await bot.send_group_msg(group_id=group,message=y)
    except:
        print("_new_events_boradcaster函数出错")
        traceback.print_exc()
        #await bot.send_group_msg(group_id=group,"出错")


###输出

####强制更新
##应该是校对完了
@on_command('gx', aliases=('更新',), only_to_me=False)
async def gx(session: CommandSession):
    try:
        await _parser()
    except:
        print("gx函数出错")
        traceback.print_exc()

# 如群聊则私聊，私聊直接发送
## 应该已经校对完了
async def group_msg_handler(session,text,group_reply='已经以私聊形式发送~'):
    global debug
    try:
        if debug==1:
            print("group_msg_handler函数，text为：\n"+text)
            print("session为：\n"+str(session))
        if session.ctx['message_type']=='group':
            if not session.ctx['group_id'] in group_list:#不在群列表中就无视
                return
            await session.send(group_reply,ignore_failure=False)
            await session.send(text,ensure_private=True,ignore_failure=False)
        elif session.ctx['message_type']=='private':
            await session.send(text,ignore_failure=False)
    except:
        print("group_msg_handler函数出错")
        traceback.print_exc()
        await session.send("出错")


####帮助
@on_command('help', aliases=('bothelp','帮助'), only_to_me=False)
async def help(session: CommandSession):
    try:
        help_str="命令列表：\n1.手动查询类：裂缝 | 突击 | 每日特惠 | 入侵 | 翻译(游戏内条目) | 新闻\n2.自动播报类：无 \n \
        2. 攻略类(请自行注意攻略时效)：配卡思路 | 萌新配卡 | 夜灵攻略 | 新手必备mod | 平原完整 | 资源获取 \n \
        查找以及修复bug中，发现问题请向群昵称为forcheck的仓鼠反馈，谢谢！\n \
        温馨提示：裂隙任务有一定的误差"

        """
        提示：已经关闭了所有的报时模块
        自动播报稀有入侵并没有了
        命令列表：
        1.手动查询类：
        警报(已无) | 裂缝 | 突击 | 金星温度 | 每日特惠 | 入侵 | 翻译(游戏内条目) | WM查询（暂时无法使用））
        
        2.自动播报类：
        警报(已无) | 稀有入侵 | 官方新闻与Twitter（删）
        
        3.咕咕咕(可能不会更新了qwq)
        地球时间 | 虚空商人(等他下次来了更新) | 建造进度(自动播报) | 平原/金星赏金任务|
        
        """
        await group_msg_handler(session,help_str)
    except:
        await group_msg_handler(session,"出错")
        print("help函数出错")
        traceback.print_exc()


####查询警报，直接到获取的json中查询，不用id列表，需要用到翻译，现在已经没有警报了
'''
@on_command('alert', aliases=('警报',), only_to_me=False)
async def alert(session: CommandSession):
    zh_list = []
    if parsed_json['alerts']:
        for x in parsed_json['alerts']:
            zh_list.append(await get_alert_text(x))
        text = await join_list_to_str(zh_list,'当前警报：')
        await group_msg_handler(session,text)
    else:
        text = '没有警报'
        group_reply = ''
        await group_msg_handler(session,text,group_reply)
'''

@on_command('earth_time',aliases=('地球时间',), only_to_me=False)
async def earth_time(session: CommandSession):
    try:
        if session.ctx['message_type']== 'group':
            if not session.ctx['group_id'] in group_list:
                return
        #await session.send(await get_earth_time(parsed_json['earthCycle']))
        await session.send("此功能暂时关闭")
    except:
        await session.send("出错")
        print("earth_time函数出错")
        traceback.print_exc()

####查询地球时间
async def get_earth_time(raw_str):#参数重复了？？？，这个函数是自己写的
    try:
        global earthtime
        text='地球时间：'
        if raw_str['state']:
            time='夜晚'
        else:
            time='白天'
        text=text+time+'\n剩余时间：'+get_timedelta(earthtime)
        #time_now=datetime.datetime.now()
        
        return text
    except:
        print("get_earth_time函数出错")
        return "出错"
        traceback.print_exc()

####查询金星山谷温度
# 温度
async def get_vallis_time(raw_str):    # = parsed_json.get('vallisCycle')
    try:
        text = '山谷现在是：寒冷'
        if raw_str['isWarm']:
            text = '山谷现在是：温暖'
        text=text+'\n剩余时间：'+get_timedelta(vallistime)
        return text
    except:
        print("get_vallis_time函数出错")
        return "出错"
        traceback.print_exc()

@on_command('valliscycle', aliases=('金星温度','平原温度','金星平原温度','山谷温度'), only_to_me=False)
async def valliscycle(session: CommandSession):
    try:
        if session.ctx['message_type'] == 'group':
            if not session.ctx['group_id'] in group_list:
                return
        #await session.send(await get_vallis_time(parsed_json['vallisCycle']))#参数重复了？？？
        await session.send("此功能暂时关闭")
    except:
        await session.send("出错")
        print("valliscycle函数出错")
        traceback.print_exc()


####查询入侵
# 筛选掉已完成的invasion
async def completed_invasion_filter(raw_list):
    try:
        if raw_list:
            new_list=[]
            for x in raw_list:
                if not x.get('completed'):
                    new_list.append(x)
            return new_list
        else:
            return None
    except:
        print("completed_invasion_filter函数出错")
        traceback.print_exc()
        return None
    

# 将类似Adora (earth)的节点英语翻译成中国话：Adora (地球)
async def node_translator(node):
    global debug
    try:
        match = re.match(r'(.*)\((.*)\)$',node)
        planet = await dict_translator(match.group(2))
        if debug==1:
            print("node_translator函数："+node+"的星球的翻译结果为："+planet)
        node = match.group(1)+planet
        return node
    except:
        print("node_translator函数出错")
        if debug==1:
            print("node_translator函数翻译失败，node为"+node)
        traceback.print_exc()
        return node
        
    
# 将入侵奖励翻译一下
async def invasion_reward_translator(raw_str):
    global parsed_invasion
    try:
        if raw_str:
            if raw_str[0].isdigit():
                item = await dict_translator(raw_str[2:],parsed_invasion)
                text = raw_str[:2]+item
            else:
                text = await dict_translator(raw_str,parsed_invasion)
        else:
            text = '无奖励'
        return text
    except:
        print("invasion_reward_translator出错")
        traceback.print_exc()

# 入侵
async def get_invasion_text(raw_str):
    try:
        completion = int(raw_str.get('completion'))
        node = await node_translator(raw_str.get('node'))#nodo形如Numa (Saturn)
        aFaction = raw_str.get('attackingFaction')
        dFaction = raw_str.get('defendingFaction')
        aReward = await invasion_reward_translator(raw_str['attackerReward']['asString'])
        dReward = await invasion_reward_translator(raw_str['defenderReward']['asString'])
        text = '节点：{node}\n阵营：{aFaction} Vs {dFaction}\n奖励：{aReward} Vs {dReward}\n进度：{completion}'.format(aFaction=aFaction,dFaction=dFaction,node=node,aReward=aReward,dReward=dReward,completion=completion)
        return text
    except:
        print("get_invasion_text函数出错")
        traceback.print_exc()
        return "出错"

##应该是校对完了
@on_command('invasion', aliases=('入侵', '入侵任务'),only_to_me=False)
async def invasion(session: CommandSession):
    try:
        global parsed_json
        raw_list = parsed_json.get('invasions')
        real_list = await completed_invasion_filter(raw_list)#得到未完成的入侵任务
        if real_list:
            zh_list = []
            for x in real_list:
                zh_list.append(await get_invasion_text(x))
            text = await join_list_to_str(zh_list,'当前入侵：')
            await group_msg_handler(session,text)
        else:
            await group_msg_handler(session,"暂无入侵")
    except:
        await group_msg_handler(session,"出错")
        print("invasion函数出错")
        traceback.print_exc()


####查询突击
@on_command('sortie', aliases=('突击','每日突击','突击任务'), only_to_me=False)
async def sortie(session: CommandSession):  
    global debug
    try:
        text = await get_sortie_text(parsed_json.get('sortie'))
        if(debug==1):
            print("get_sortie_text函数返回的字符串为：\n"+text)
        await group_msg_handler(session,text)
    except:
        print("sortie函数出错")
        traceback.print_exc()

# 突击
async def get_sortie_text(raw_str,simplified=0):#传入突击列表
    global debug
    try:
        if(raw_str==None):
            return "无突击任务"
        text=''
        if simplified:#简化，不翻译
            Faction = (raw_str.get('faction') or '未知')#派系
            for x in raw_str.get('variants'):
                mission_type = await dict_translator(x['missionType'])
                text +='\n{type}'.format(type=mission_type)
        else:
            if(debug==1):
                print("get_sortie_text的非simplified分支")
            Boss = await dict_translator(raw_str['boss'])
            Faction = (raw_str.get('faction') or '未知')
            text = '今日突击：\nBoss：{boss_en} {boss}\n阵营：{f}'.format(boss_en=raw_str['boss'],boss=Boss,f=Faction)
            if(debug==1):
                print("get_sortie_text中Boss为："+Boss+" 阵营为："+str(Faction))
            for x in raw_str['variants']:
                node = await node_translator(x['node'])
                mission_type = await dict_translator(x['missionType'])
                #处理特殊：
                #modifier = await dict_translator(x['modifier'])
                mod=x['modifier'].split(':')
                modifier=''
                for i in mod:
                    modifier+=await dict_translator(i.strip())+" "
                text +='\n\n节点：{node}\n类型：{type}\n特殊：{mod}'.format(node=node,type=mission_type,mod=modifier)
        return text
    except:
        print('get_sortie_text函数执行失败')
        if(raw_str==None):
            print("传入的str空")
        traceback.print_exc()
        return "查询突击列表失败"


####查询每日特惠
@on_command('dailydeals', aliases=('每日特惠','特惠'), only_to_me=False)
async def dailydeals(session: CommandSession):
    text = await get_dailysale_text(parsed_json['dailyDeals'][0])
    await group_msg_handler(session,text)
    
# 每日特惠
async def get_dailysale_text(raw_str):#传入dict
    try:
        item = await dict_translator(raw_str['item'])
        price = raw_str['salePrice']
        discount=raw_str['discount']
        eta = raw_str['eta']##涉及时间
        total = raw_str['total']
        sold=raw_str['sold']
        left = total - sold
        text = '本日特惠：\n商品：{item}\n价格：{price}({discount}%off)\n还剩：{left}({sold}/{total})\n剩余时间：{eta}'.format(item=item,price=price,discount=discount,left=left,sold=sold,total=total,eta=eta)
        return text
    except:
        print("get_dailysale_text函数执行出错")
        traceback.print_exc()
        return "未查询到所需信息"

####查询裂隙
@on_command('fissure', aliases=('裂缝','裂隙'), only_to_me=False)
async def fissure(session: CommandSession):
    try:
        text = await get_fissure_text(parsed_json['fissures'])
        await group_msg_handler(session,text)
    except:
        print("fissure函数出错")
        traceback.print_exc()
        await group_msg_handler(session,"出错")

# 裂缝
async def get_fissure_text(raw_list):##传入一个list
    global debug
    try:
        if debug==1:
            print("get_fissure_text函数，传入为：")
            print(str(raw_list))
        fissures=[[],[],[],[],[]]
        for x in raw_list:
            node =await node_translator(x['node'])
            mission_type = await dict_translator(x['missionType'])
            eta = x['eta']          
            mission_text = '节点：{n}\n类型：{t}\n剩余时间：{e}'.format(n=node,t=mission_type,e=eta)
            fissures[int(x['tierNum'])-1].append(mission_text)
        t1=await join_list_to_str(fissures[0],'————古纪————')#检查这个函数去了
        t2=await join_list_to_str(fissures[1],'————前纪————')
        t3=await join_list_to_str(fissures[2],'————中纪————')
        t4=await join_list_to_str(fissures[3],'————后纪————')
        t5=await join_list_to_str(fissures[4],'————安魂————')
        return t1+'\n'+t2+'\n'+t3+'\n'+t4+'\n'+t5
    except:
        print("get_fissure_text函数出错")
        traceback.print_exc()
        return "出错"


####查询平原时间
##应该是校对完了
@on_command('cytuscycle', aliases=('平原时间','希图斯时间','地球平原时间'), only_to_me=False)
async def cytuscycle(session: CommandSession):
    try:
        '''
        ##只对特定的群有反应
        if session.ctx['message_type'] == 'group':
            if not session.ctx['group_id'] in group_list:
                return
        await session.send(await get_cetus_time(parsed_json['cetusCycle']))
        '''
        #也从帮助文档中去除了，注意修改
        await session.send("该功能暂时关闭")
    except:
        print("cytuscycle函数出错")
        traceback.print_exc()
        await session.send("出错")

# 平原时间
##应该是校对完了
async def get_cetus_time(raw_str):
    try:
        text = '平原现在是：黑夜'
        if raw_str['isDay']==True:
            text = '平原现在是：白天'
        text=text+'\n剩余时间：'+get_timedelta(cetustime)
        return text
    except:
        print("get_cetus_time函数出错")
        traceback.print_exc()
        return "出错"
    
####翻译
##看不出来有没有错
@on_command('translate',aliases=('翻译',),only_to_me=False)
async def translate(session: CommandSession):
    if session.ctx['message_type'] == 'group':
        if not session.ctx['group_id'] in group_list:
            return
    en_str = session.get('en_str', prompt='请输入你要查询的字符串')
    zh_str = await dict_translator(en_str)
    await session.send(zh_str+ ' ' + en_str)
@translate.args_parser
async def _kfkfkfk(session: CommandSession):
    # 去掉消息首尾的空白符
    stripped_arg = session.current_arg_text.strip()
    if session.is_first_run:
        # 该命令第一次运xing（第一次进入命令会话）
        if stripped_arg:
            # 第一次运行参数不为空，意味着用户直接将城市名跟在命令名后面，作为参数传入
            session.state['en_str'] = stripped_arg
        return

    if not stripped_arg:
        # 用户没有发送有效的城市名称（而是发送了空白字符），则提示重新输入
        # 这里 session.pause() 将会发送消息并暂停当前会话（该行后面的代码不会被运行）
        session.pause('要查询的字符串不能为空，请重新输入')
    session.state[session.current_key] = stripped_arg


####查询新闻，暂时关闭
##应该已经校对完了
@on_command('news',aliases=('新闻',), only_to_me=False)
async def see_news(session: CommandSession):
    try:
        text=''.join(await get_news_list(parsed_json['news']))
        await group_msg_handler(session,text)
    except:
        print("see_news函数出错")
        traceback.print_exc()
        await group_msg_handler(session,"出错")

####查询新闻
##应该已经校对完了
@on_command('jianshang',aliases=('虚空商人','奸商'), only_to_me=False)
async def see_news(session: CommandSession):
    try:
        text=await see_voidTrader(parsed_json['voidTrader'])
        await group_msg_handler(session,text)
    except:
        print("see_news函数出错")
        traceback.print_exc()
        await group_msg_handler(session,"出错")

async def see_voidTrader(raw_str):
    global debug
    try:
        text=''
        if raw_str['active']==False:
            if debug==1:
                print("虚空商人未到来")
            pass
        else:
            if debug==1:
                print("虚空商人已到来")
            pass
    except:
        traceback.print_exc()
